Amiga Plus 2004 #2

home *** CD-ROM | disk | FTP | other *** search

/ Amiga Plus 2004 #2 / Amiga Plus CD - 2004 - No. 02.iso / AmiSoft / Dev / misc / StripHunk.lha / StripHunk / StripHunk.s < prev next >

Wrap

Text File | 2003-12-26 | 52.8 KB | 1,780 lines

***************************************************************************** * * * PROGRAM: StripHunk * * VERSION: 1.3 * * SOURCE CODE: 28 (7.11.2000) * * DATE: 23.09.1997 - 05.10.1999 * * LANGUAGE: Assembler (DevPac V3.14) * * SYSTEM: A1200 KS 40.68 WB 40.42 2MB chip 8MB fast 68030/50mhz * * * * AUTHOR: Joerg Riemer 14167 Berlin/SchottmuellerStr.107/Germany * * EMAIL: joerg_riemer@freenet.de / mission@cs.tu-berlin.de * * * * FUNCTION: changes hunk_reloc32 <-> hunk_drel32 * * removes debug_hunks like $3E8,$3F0,$3F1 * * sorts reloc_entrys from low to high and reverse * * * ***************************************************************************** BSS_Section set 0 ***************************************************************************** OUTPUT RAM:StripHunk ***************************************************************************** ASLFR_DoMultiSelect equ $8008002D ASLFR_DoPatterns equ $8008002E ASLFR_DoSaveMode equ $8008002C ASLFR_DrawersOnly equ $8008002F ASLFR_InitialFile equ $80080008 ASLFR_TitleText equ $80080001 fr_Drawer equ $008 fr_File equ $004 fr_ArgList equ $024 fr_NumArgs equ $020 _LVOAllocAslRequest equ -048 _LVOFreeAslRequest equ -054 _LVOAslRequest equ -060 ***************************************************************************** HUNK_HEADER equ 1011 MODE_OLDFILE equ 1005 MODE_NEWFILE equ 1006 ACCESS_READ equ -002 fib_Protection equ $074 fib_Size equ $07C fib_Comment equ $090 fib_SIZEOF equ $104 FIBB_ARCHIVE equ $004 _LVOOpen equ -030 _LVOClose equ -036 _LVORead equ -042 _LVOWrite equ -048 _LVOOutput equ -060 _LVODeleteFile equ -072 _LVORename equ -078 _LVOLock equ -084 _LVOUnLock equ -090 _LVOCurrentDir equ -126 _LVOIoErr equ -132 _LVOSetComment equ -180 _LVOSetProtection equ -186 _LVOFlush equ -360 _LVOExamineFH equ -390 _LVOSetIoErr equ -462 _LVOPrintFault equ -474 _LVOCheckSignal equ -792 _LVOReadArgs equ -798 _LVOFreeArgs equ -858 _LVOFilePart equ -870 _LVOPutStr equ -948 _LVOVPrintf equ -954 ***************************************************************************** _LVOAllocMem equ -198 _LVOFreeMem equ -210 _LVOCloseLibrary equ -414 _LVOOpenLibrary equ -552 _LVOCacheClearU equ -636 ***************************************************************************** DataBase1 rs.b 0 DOSBase rs.l 1 ASLBase rs.l 1 ***************************************************************************** ArgArray rs.b 0 LFile rs.l 1 SFile rs.l 1 Replace rs.l 1 DRel32 rs.l 1 Split rs.l 1 Reloc32 rs.l 1 Sort rs.l 1 Reverse rs.l 1 ;sort reverse (7.11.00) Symbol rs.l 1 Debug rs.l 1 Name rs.l 1 Zeros rs.l 1 AslReq rs.l 1 Quiet rs.l 1 RArgPtr rs.l 1 ***************************************************************************** FileCnt rs.l 1 ;counter (files to operate) ***************************************************************************** ASLFlag rs.l 1 ;flag (using ASL) LREQBase rs.l 1 SREQBase rs.l 1 ***************************************************************************** RCode rs.l 1 ;buffer for returncode IOErr rs.l 1 ;buffer for io_error ***************************************************************************** DataBase2 rs.b 0 ;cleared for every file LName rs.b 32 ;buffer filename (load) SName rs.b 32 ;buffer filename (save) BName rs.b 32 ;buffer backupname LPath rs.l 1 ;strptr path (load) LPLock rs.l 1 ;lock currentdir (load) OldLDir rs.l 1 ;lock prev. dir FHandleL rs.l 1 ;filehandle (old file) SPath rs.l 1 ;strptr path (save) SPLock rs.l 1 ;lock currentdir (save) OldSDir rs.l 1 ;lock prev. dir FHandleS rs.l 1 ;filehandle (new file) OvlHunk rs.l 1 ;pointer overlay_hunk RdSize rs.l 1 ;reduced size (over all) NFSize rs.l 1 ;new filesize Memory rs.l 1 ;mem-ptr (current file) EFlag1 rs.b 1 ;overlay found EFlag2 rs.b 1 ;(name/symbol/debug) removed EFlag3 rs.b 1 ;reloc changed (strip/revert) EFlag4 rs.b 1 ;save error EFlag5 rs.b 1 ;empty hunk found EFlag6 rs.b 1 ;dummy for longword align EFlag7 rs.b 1 ;dummy for longword align EFlag8 rs.b 1 ;dummy for longword align ProgID rs.l 2 ;buffer for hunk_header_id Buffer rs.l 1 *********************************************** file info block ************ FIBlock rs.b fib_SIZEOF ;buffer for fileinfoblock BSS_Size1 rs.b 0 ;bss_size over all BSS_Size2 set BSS_Size1-DataBase2 ;required for inner circle ***************************************************************************** if BSS_Section ProgStart movea.l ProgStart-4(pc),A5 ;get bss_section addq.l #1,A5 ;skip pointer (next segment) adda.l A5,A5 ;convert bpcl_pointer adda.l A5,A5 ;to real_address elseif ProgStart lea DataBase(pc),A5 ;get database endc ***************************************************************************** movea.l 4.w,A6 ;set EXEC to call a function moveq #20,D0 ;get failat level move.l D0,RCode(A5) ;preset returncode (no dos) moveq #37,D0 ;set required version lea DOSName(pc),A1 ;get libraryname jsr _LVOOpenLibrary(A6) ;use EXEC to (openlibrary) move.l D0,DOSBase(A5) ;save returned pointer beq.b CloseLibs ;branch on fail moveq #0,D0 ;set required version lea ASLName(pc),A1 ;get libraryname jsr _LVOOpenLibrary(A6) ;use EXEC to (openlibrary) move.l D0,ASLBase(A5) ;save returned pointer ***************************************************************************** bsr.b Main0 ***************************************************************************** CloseLibs movea.l 4.w,A6 ;set EXEC to call a function move.l ASLBase(A5),D1 ;get base_ptr beq.b CloseDOS ;branch when not open movea.l D1,A1 ;set base_ptr jsr _LVOCloseLibrary(A6) ;use EXEC to (closelibrary) CloseDOS move.l DOSBase(A5),D1 ;get base_ptr beq.b QuitClose ;branch when not open movea.l D1,A1 ;set base_ptr jsr _LVOCloseLibrary(A6) ;use EXEC to (closelibrary) QuitClose move.l RCode(A5),D0 ;set returncode rts ;back to shell ***************************************************************************** DOSName dc.b "dos.library",0 ASLName dc.b "asl.library",0 ***************************************************************************** version dc.b "$VER: striphunk 1.3 28 (7.11.00) by joerg riemer sep'97",0,0 ***************************************************************************** Main0 bsr ReadArgs ;read arguments by dos bsr CheckArgs ;check for wrong arguments bsr OpenREQs ;open filerequester Main1 moveq #0,D0 ;get failat level move.l D0,RCode(A5) ;set returncode Main2 movea.l DOSBase(A5),A6 ;set DOS to call a function bsr ChkBreak ;check for break by (ctrl_c) bsr PrepLSrc ;prepare fname/fdir. (src.) bsr PrintT00 ;print "processing FILE:" bsr LoadFile ;load file bsr PrepFile ;parse file, strip hunks bsr ChkBreak ;check for break by (ctrl_c) bsr PrepSDst ;prepare fname/fdir. (dst.) bsr PrintTBS ;print "bytes saved" bsr PrintT02 ;print "writing" bsr SaveFile ;save file to disk bsr PrintT04 ;print "done." Main3 bsr.b FreeMem ;free file_mem bsr.b ResetData ;clear used datas moveq #1,D0 ;decrement sub.l D0,FileCnt(A5) ;file counter bpl.b Main2 ;loop until -1 Main4 bsr.b CloseREQ ;free both asl requester bsr.b FreeArgs ;unset readargs bsr.b SetIOErr ;try to set last io_error rts ;go back to shell *********************************************** clear database ************* ResetData lea DataBase2(A5),A0 ;get base of datas move.w #BSS_Size2-1,D0 ;set size to clear moveq #0,D1 ;prepare clear register ClearMemory move.b D1,(A0)+ ;clear datas dbra D0,ClearMemory ;until overflow rts ;go back *********************************************** free file memory *********** FreeMem move.l Memory(A5),D1 ;get file memory beq.b QuitFreeM ;branch if not set movea.l D1,A1 ;set memory base lea FIBlock(A5),A0 ;get fileinfoblock move.l fib_Size(A0),D0 ;set filesize add.l D0,D0 ;add working area movea.l 4.w,A6 ;set EXEC to call a function jsr _LVOFreeMem(A6) ;use EXEC to (freemem) QuitFreeM rts ;go back ***************************************************************************** CloseREQ movea.l ASLBase(A5),A6 ;set ASL to call a function move.l LREQBase(A5),D0 ;test requester base beq.b CloseFREQ ;branch if not open movea.l D0,A0 ;set requester base jsr _LVOFreeAslRequest(A6) ;use ASL to (freeaslrequest) CloseFREQ move.l SREQBase(A5),D0 ;test requester base beq.b QuitCREQ ;branch if not open movea.l D0,A0 ;set requester base jsr _LVOFreeAslRequest(A6) ;use ASL to (freeaslrequest) QuitCREQ rts ;go back *********************************************** free arguments ************* FreeArgs lea ArgArray(A5),A1 ;get argarray move.l RArgPtr(A5),D1 ;set readarg pointer movea.l DOSBase(A5),A6 ;set DOS to call a function jsr _LVOFreeArgs(A6) ;use DOS to (freeargs) rts ;go back *********************************************** set last io_error ********** SetIOErr move.l IOErr(A5),D1 ;set last io_error beq.b QuitIOErr ;branch if there is nothing movea.l DOSBase(A5),A6 ;set DOS to call a function jsr _LVOSetIoErr(A6) ;use DOS to (setioerr) QuitIOErr rts ;go back *********************************************** strip/revert hunks/relocs ** PrepFile movea.l Memory(A5),A0 ;get base of current file movea.l A0,A1 ;prepare end of file lea FIBlock(A5),A2 ;get fileinfoblock adda.l fib_Size(A2),A1 ;add filesize Loop cmpa.l A0,A1 ;check for eof bne.b ParseHunk ;branch if so move.l A1,D0 ;set end of file sub.l Memory(A5),D0 ;calculate new filesize move.l D0,NFSize(A5) ;and save move.b EFlag2(A5),D0 ;removed some hunks ? or.b EFlag3(A5),D0 ;stripped some relocs ? bne.b QuitParse ;branch if so bsr PrintT06 ;print "untouched" addq.l #4,SP ;skip some sub-routines pea Main3(pc) ;do the next file QuitParse rts ;go back ************************************************ ParseHunk move.l (A0),D0 ;get hunk_id from file moveq #23,D1 ;set loop counter lea HunkTable(pc),A2 ;set id_table SearchID move.w D1,D2 ;prepare offset add.w D2,D2 ;want it in words cmp.w (A2,D2.W),D0 ;found hunk_id ? dbeq D1,SearchID ;dbranch if not bne PrintError1 ;branch when nothing found move.w JmpTable(pc,D2),D2 ;calculate jump_address jmp JmpTable(pc,D2) ;parse current hunk *** available hunks ********************************************************* * * * 00)*hunk_unit -( 999/$3E7) 01)+hunk_name #(1000/$3E8) * * 02)+hunk_code #(1001/$3E9) 03)+hunk_data #(1002/$3EA) * * 04)+hunk_bss #(1003/$3EB) 05)+hunk_reloc #(1004/$3EC) * * 06)*hunk_reloc16 -(1005/$3ED) 07)*hunk_reloc8 -(1006/$3EE) * * 08)*hunk_ext -(1007/$3EF) 09)+hunk_symbol #(1008/$3F0) * * 10)+hunk_debug #(1009/$3F1) 11)+hunk_end #(1010($3F2) * * 12)+hunk_header #(1011/$3F3) 13)* (1012/$3F4) * * 14)+hunk_overlay #(1013/$3F5) 15)+hunk_break #(1014/$3F6) * * 16)+hunk_drel32 #(1015/$3F7) 17)*hunk_drel16 ?(1016/$3F8) * * 18)*hunk_drel8 ?(1017/$3F9) 19)*hunk_lib ?(1018/$3FA) * * 20)*hunk_index ?(1019/$3FB) 21)+hunk_reloc32short #(1020/$3FC) * * 22)*hunk_relreloc32 ?(1021/$3FD) 23)*hunk_absreloc16 ?(1022/$3FE) * * * ***************************************************************************** HunkTable dc.w $3E7,$3E8,$3E9,$3EA,$3EB,$3EC,$3ED,$3EE dc.w $3EF,$3F0,$3F1,$3F2,$3F3,$3F4,$3F5,$3F6 dc.w $3F7,$3F8,$3F9,$3FA,$3FB,$3FC,$3FD,$3FE JmpTable dc.w PrintError1-JmpTable,ParseHunk01-JmpTable dc.w ParseHunk02-JmpTable,ParseHunk03-JmpTable dc.w ParseHunk04-JmpTable,ParseHunk05-JmpTable dc.w PrintError1-JmpTable,PrintError1-JmpTable dc.w PrintError1-JmpTable,ParseHunk09-JmpTable dc.w ParseHunk10-JmpTable,ParseHunk11-JmpTable dc.w ParseHunk12-JmpTable,PrintError1-JmpTable dc.w ParseHunk14-JmpTable,ParseHunk15-JmpTable dc.w ParseHunk16-JmpTable,PrintError1-JmpTable dc.w PrintError1-JmpTable,PrintError1-JmpTable dc.w PrintError1-JmpTable,ParseHunk21-JmpTable dc.w PrintError1-JmpTable,PrintError1-JmpTable * hunk_name #(1000/$3E8) **************************************************** ParseHunk01 tst.b Name(A5) ;delete hunk_name ? beq.b ParseHunk02 ;branch if not ************************ DeleteHunk st EFlag2(A5) ;set flag (hunk removed) movea.l A0,A2 ;prepare work_register addq.l #4,A2 ;skip hunk_id move.l (A2),D0 ;set hunk_length lsl.l #2,D0 ;want it in bytes lea 4(A2,D0.l),A2 ;get hunk_end ************************ ShrinkFile st EFlag3(A5) ;set flag (file changed) move.l A0,D0 ;calculate size sub.l A2,D0 ;to shrink add.l D0,RdSize(A5) ;add (reduced)size [over all] .Shrink move.l (A2),(A2,D0.l) ;shrink file addq.l #4,A2 ;long by long cmpa.l A2,A1 ;until eof bne.b .Shrink adda.l D0,A1 ;file is now bit smaller bra Loop ;go back (parse next hunk) * hunk_debug #(1009/$3F1) ********************* ParseHunk10 tst.b Debug(A5) ;want to remove hunk_debug ? bne.b DeleteHunk ;branch if so * hunk_data #(1002/$3EA) ********************** ParseHunk03 ;same like hunk_code * hunk_code #(1001/$3E9) ********************** ParseHunk02 addq.l #4,A0 ;skip hunk_id movea.l A0,A2 ;hunk_length, required later move.l (A0),D0 ;get longs to skip sne EFlag5(A5) ;set flag if hunk empty lsl.l #2,D0 ;want it in bytes lea 4(A0,D0.l),A0 ;jump to hunk_end tst.b EFlag5(A5) ;check for empty hunk beq Loop ;branch if so tst.b Zeros(A5) ;remove zeros ? beq Loop ;branch if not movea.l A0,A3 ;prepare work_register .ChkZeros tst.l -(A0) ;calc length beq.b .ChkZeros ;of zeros (backward) addq.l #4,A0 ;reset address cmpa.l A0,A3 ;found some zeros ? beq Loop ;branch if not st EFlag2(A5) ;set flag, backup only move.l A3,D0 ;recalculate sub.l A0,D0 ;hunk_length lsr.l #2,D0 ;requires longs sub.l D0,(A2) ;reset hunk_length movea.l A3,A2 ;prepare work_register bra.b ShrinkFile ;and shrink file * hunk_symbol #(1008/$3F0) ******************** ParseHunk09 movea.l A0,A2 ;save hunkbase addq.l #4,A0 ;skip hunk_id move.l (A0)+,D0 ;get longs to skip beq.b .RemoveSymbol ;branch if end_mark .SkipSymbol lsl.l #2,D0 ;want it in bytes lea 4(A0,D0.l),A0 ;skip symbol move.l (A0)+,D0 ;get longs to skip bne.b .SkipSymbol ;do the next .RemoveSymbol tst.b Symbol(A5) ;want to remove hunk_symbol ? beq Loop ;no,go back (parse next hunk) st EFlag2(A5) ;set flag,symbol_hunk removed exg.l A0,A2 ;prepare work_register bra ShrinkFile ;remove symbol hunk * hunk_bss #(1003/$3EB) *********************** ParseHunk04 addq.l #4,A0 ;skip hunk_id * hunk_break #(1014/$3F6) ********************* ParseHunk15 ;same like hunk_end * hunk_end #(1010/$3F2) *********************** ParseHunk11 addq.l #4,A0 ;skip hunk_id / bss_size bra Loop ;go back (parse next hunk) * hunk_overlay #(1013/$3F5) ******************* ParseHunk14 tst.b EFlag1(A5) ;only one overlay, please bne PrintError1 ;branch if not st EFlag1(A5) ;set flag, overlay found movem.l A0-1,-(SP) ;save registers bsr PrintT05 ;print "contains overlay" movem.l (SP)+,A0-1 ;restore registers move.l A0,OvlHunk(A5) ;save base of overlay_hunk addq.l #4,A0 ;skip hunk_id move.l (A0)+,D0 ;read hunk_size move.l (A0)+,D1 ;read max. tree_node subq.l #1,D1 ;prepare register sub.l D1,D0 ;skip tree_node buffers subq.l #1,D1 ;prepare dbra_loop .ChkOverlay tst.l (A0)+ ;node_buffers must be zero bne PrintError2 ;branch if not dbra D1,.ChkOverlay ;check the next lsl.l #2,D0 ;want it in bytes lea (A0,D0.l),A0 ;skip overlay_hunk bra Loop ;go back (parse next hunk) * hunk_header #(1011/$3F3) ******************** ParseHunk12 movea.l A0,A2 ;save base addq.l #4,A0 ;skip hunk_id tst.l (A0)+ ;must be 0 (resident libs) bne PrintError1 ;branch if not addq.l #4,A0 ;skip hunk counter move.l (A0)+,D1 ;read first hunk to load move.l (A0)+,D0 ;read last hunk to load sub.l D1,D0 ;calc buffers to skip lsl.l #2,D0 ;want it in bytes lea 4(A0,D0.w),A0 ;skip buffers (hunk length) ************************ tst.b EFlag1(A5) ;overlay file ? beq Loop ;no,go back (parse next hunk) movea.l OvlHunk(A5),A3 ;get base (overlay_hunk) addq.l #4,A3 ;skip hunk_id move.l (A3)+,D0 ;read length in longs move.l (A3)+,D1 ;read tree_node subq.l #1,D1 ;prepare register sub.l D1,D0 ;skip tree_node buffers subq.l #1,D1 ;in case of dbra .ChkOverlay tst.l (A3)+ ;test tree_node buffers bne PrintError2 ;branch if not null dbra D1,.ChkOverlay ;check all buffers move.l RdSize(A5),D1 ;set rdsize upto current pos. move.l A2,D2 ;calculate overlay sub.l Memory(A5),D2 ;seekOffset for the sub.l D1,D2 ;current hunk_header .SetSOffset cmp.l (A3),D2 ;search for ovl_seekOffset bne.b .SkipSOffset ;branch if not the same add.l D1,(A3) ;recalculate ovl_seekOffset .SkipSOffset addq.l #4,A3 ;skip seekOffset_buffer tst.l (A3)+ ;test dummy, must be zero bne PrintError2 ;branch if not tst.l (A3)+ ;test dummy, must be zero bne PrintError2 ;branch if not adda.w #20,A3 ;get next overlay_entry subq.l #8,D0 ;reduce hunk_length bne.b .SetSOffset ;do for all entries bra Loop ;go back (parse next hunk) * hunk_reloc #(1004/$3EC) ********************* ParseHunk05 tst.b Reloc32(A5) ;want reloc32 ? bne Merge ;branch if so * extract drel32_entries ********************** movea.l A0,A2 ;set base of current hunk movea.l A1,A3 ;set destination area moveq #11,D0 ;prepare register add.l (A2)+,D0 ;calculate new hunk_id move.l D0,(A3)+ ;and write moveq #0,D3 ;clr counter (drel32_entries) move.l A3,A4 ;save buffer (# of drels) move.l (A2)+,D0 ;get # of relocs beq.b EndDRel32 ;branch if zero SplitDRel32 move.w D0,(A3)+ ;dummy_write # of drels move.l (A2)+,D1 ;get module # move.w D1,(A3)+ ;write module # subq #1,D0 ;prepare dbra_loop moveq #0,D2 ;clr counter (drel32_entries) NextDRel32 move.w (A2)+,D1 ;check the high_word bne.b SkipReloc32 ;must be 0, skip move.w (A2),(A3)+ ;copy drel32 addq #1,D2 ;inc. counter (drel32_entries) SkipReloc32 addq #2,A2 ;skip low-word dbra D0,NextDRel32 ;do for all entries move.w D2,(A4) ;write new # of drels bne.b .NextModule ;split next module move.l A4,A3 ;else, reset dest. address .NextModule move.l A3,A4 ;save buffer (# of drels) add.l D2,D3 ;add entries we found move.l (A2)+,D0 ;read entries of next module bne.b SplitDRel32 ;split next module if set EndDRel32 move.l D0,(A3) ;write hunk_end *********************************************** tst.l D3 ;found some drels ? beq.b SkipHunk ;branch if not addq #2,A3 ;skip hunk_end move.l A3,D0 ;be sure it's long aligned addq.l #03,D0 ;calculate long_align andi.b #-4,D0 ;calculate long_align move.l D0,A3 ;reset dest. address move.l A3,Buffer(A5) ;set hunk end (drel32 only) * extract reloc32_entries ********************* movea.l A0,A2 ;set reloc_hunk again move.l (A2)+,(A3)+ ;copy hunk_id (reloc32) moveq #0,D4 ;clear counter (reloc32) movea.l A3,A4 ;save buffer (# of relocs) move.l (A2)+,D0 ;read # of relocs beq.b EndReloc32 ;branch if zero SplitReloc32 move.l D0,(A3)+ ;dummy_write # of relocs move.l (A2)+,(A3)+ ;copy module # subq #1,D0 ;prepare dbra_loop moveq #0,D2 ;clear counter (reloc32) NextReloc32 move.w (A2)+,D1 ;check high word beq.b SkipDRel32 ;branch if drel32 move.w D1,(A3)+ ;copy high word move.w (A2),(A3)+ ;copy low word addq #1,D2 ;inc. counter (reloc32) SkipDRel32 addq #2,A2 ;reset source address dbra D0,NextReloc32 ;do for all relocs move.l D2,(A4) ;write new # of relocs bne.b .NextModule ;split next module move.l A4,A3 ;reset dest. address .NextModule move.l A3,A4 ;save buffer (# of relocs) add.l D2,D4 ;add entries we found move.l (A2)+,D0 ;read next # of relocs bne.b SplitReloc32 ;do next module if set EndReloc32 move.l D0,(A3)+ ;write hunk_end ************************ tst.l D4 ;found some relocs ? beq.b GenerateReloc ;branch if not move.l A3,Buffer(A5) ;set hunk end (both joined) tst.b Split(A5) ;want to split ? beq.b SkipHunk ;branch if not moveq #6,D0 ;requires more than 5 drels cmp.l D0,D3 ;check for more bls.b SkipHunk ;branch if not GenerateReloc tst.b DRel32(A5) ;want short_relocs ? bne.b SetDrel32 ;branch if so SkipHunk tst.b Sort(A5) ;want to sort ? bne SortReloc32 ;branch if so movea.l A2,A0 ;reset parsing pointer bra Loop ;go parse next hunk ************************ SetDrel32 st EFlag3(A5) ;set flag (file changed) move.l Buffer(A5),D1 ;set hunk end (drel/joined) sub.l A1,D1 ;calculate hunk size lsr.l #2,D1 ;requires longs move.l A0,-(SP) ;save current parsing pointer movea.l A1,A3 ;set base new hunk .ReplaceHunk move.l (A3)+,(A0)+ ;replace hunk subq.l #1,D1 ;long by long bne.b .ReplaceHunk ;until zero move.l A0,D0 ;calculate size sub.l A2,D0 ;to shrink add.l D0,RdSize(A5) ;add (reduced)size [over all] movea.l A2,A3 ;calculate new adda.l D0,A3 ;parsing pointer .Shrink move.l (A2),(A2,D0.l) ;shrink file addq.l #4,A2 ;long by long cmpa.l A2,A1 ;until eof bne.b .Shrink adda.l D0,A1 ;file is now bit smaller movea.l (SP)+,A0 ;restore current parsing ptr. tst.b Sort(A5) ;want to sort ? bne.b SortDRel32 ;branch if so movea.l A3,A0 ;reset parsing pointer bra Loop ;go back (parse next hunk) * hunk_drel32 #(1015/$3F7) ******************** ParseHunk16 * hunk_reloc32short #(1020/$3FC) ************** ParseHunk21 tst.b Reloc32(A5) ;want to revert ? bne.b Merge ;branch if so tst.b Sort(A5) ;want to sort ? bne.b SortDRel32 ;branch if so addq.l #4,A0 ;skip hunk_id move.w (A0)+,D0 ;get words to skip beq.b .align4 ;branch if zero .SkipDRel add.w D0,D0 ;want it in bytes lea 2(A0,D0.w),A0 ;jump to the next module move.w (A0)+,D0 ;get words to skip bne.b .SkipDRel ;do until eoh .align4 move.l A0,D0 ;be sure, it's long aligned addq.l #03,D0 ;calculate long_align andi.b #-4,D0 ;calculate long_align movea.l D0,A0 ;reset parsing pointer bra Loop ;go back (parse next hunk) *********************************************** sort relocs (16 bit) ******* * thanks dear thomas for the sort_part. i'm sure you will * read this. if so, send an email!!! :)) SortDRel32 addq.l #4,a0 ;skip hunk_id move.w (A0)+,D0 ;set # of relocs beq.b .QuitSort ;branch if zero .SortModule addq.l #2,A0 ;skip # module move.w D0,D1 ;set # of relocs lsr.w #1,D1 ;calculate 1/2 of .Sort move.w D1,D2 ;prepare register move.w D1,D3 ;prepare register sub.w D0,D2 ;calculate loop_counter movea.l A0,A2 ;set module base lsl.w #1,D3 ;want 1/2 of in bytes lea (A2,D3.W),A3 ;set base of destination moveq #0,D3 ;clear sort_flag .CheckEntry cmpm.w (A2)+,(A3)+ ;compare entries bcc.b .SkipEntry ;branch if source lower move.w -2(A2),D4 ;swap entries move.w -2(A3),-2(A2) ;swap entries move.w D4,-2(A3) ;swap entries st D3 ;set flag (some sorted) st EFlag3(A5) ;set flag (file changed) .SkipEntry addq.w #1,D2 ;increment loop counter bmi.b .CheckEntry ;do until zero tst.b D3 ;sorted some bytes ? bne.b .Sort ;if so, sort part again! lsr.w #1,D1 ;increment sort_range bne.b .Sort ;sort next part until zero move.l A3,A0 ;get next module move.w (A0)+,D0 ;get # of relocs bne.b .SortModule ;sort next when set! .QuitSort move.l A0,D0 ;be sure, it's long aligned addq.l #03,D0 ;calculate long_align andi.b #-4,D0 ;calculate long_align movea.l D0,A0 ;reset parsing pointer bra Loop ;go back (parse next hunk) ***************************************************************************** Merge movea.l A0,A2 ;prepare work_register movea.l A1,A3 ;prepare work_register moveq #0,D1 ;prepare work_register moveq #0,D7 ;prepare work_register move.l #$3EC,(A3)+ ;set hunk_id (reloc32) ************************ CheckMerge pea CheckMerge(pc) ;set return_address move.l (A2)+,D0 ;get hunk_id cmp.w #$3EC,D0 ;check for reloc32 beq.w CopyReloc32 ;branch if so cmp.w #$3F7,D0 ;check for drel32 (2.00+) beq.w CopyDRel32 ;branch if so cmp.w #$3FC,D0 ;check for true drel32 beq.w CopyDRel32 ;branch if so addq #4,SP ;remove return_address ************************ subq.l #4,A2 ;restore base addq.l #4,A3 ;restore base tst.l D1 ;found some hunks? beq.b QuitMerge ;branch if not tst.b D7 ;found some drel32_hunks? bne.b MergeHunks ;branch if so QuitMerge tst.b Sort(A5) ;want to sort relocs? bne.b SortReloc32 ;branch if so movea.l A2,A0 ;reset parsing pointer bra Loop ;go back (parse next hunk) ************************************************ MergeHunks subq.l #1,D1 ;found only one hunk? beq.b AddFile ;branch if so move.l A2,-(SP) ;save register bsr MergeModules ;merge all modules move.l (SP)+,A2 ;restore register AddFile move.l A2,D0 ;calc length (old reloc_hunk) sub.l A0,D0 ;calc length (old reloc_hunk) move.l A3,D1 ;calc length (new reloc_hunk) sub.l A1,D1 ;calc length (new reloc_hunk) AddPart move.l (A2)+,(A3)+ ;join rest of datas cmp.l A2,A1 ;upto eof bne.b AddPart ;do until! move.l A3,D2 ;calc length (new reloc_hunk) sub.l A1,D2 ;+ rest of file lsr.l #2,D2 ;want it in longwords movea.l A0,A2 ;set destination movea.l A1,A3 ;set source ReplacePart move.l (A3)+,(A2)+ ;overwrite old reloc_hunk subq.l #1,D2 ;replace by the new one bne.b ReplacePart ;do it until eof st EFlag3(A5) ;set flag (file changed) sub.l D1,D0 ;calc new file_length sub.l D0,RdSize(A5) ;calc new file_length movea.l A2,A1 ;set new file_end tst.b Sort(A5) ;want to sort relocs? bne.b SortReloc32 ;branch if so adda.l D1,A0 ;reset parsing pointer bra Loop ;go back (parse next hunk) *********************************************** sort relocs (32 bit) ******* SortReloc32 addq.l #4,A0 ;skip hunk_id move.l (A0)+,D0 ;set # of relocs beq.b .QuitSort ;branch if zero .SortModule addq.l #4,A0 ;skip # module move.l D0,D1 ;set # of relocs lsr.l #1,D1 ;calculate 1/2 of .Sort move.l D1,D2 ;prepare register move.l D1,D3 ;prepare register sub.l D0,D2 ;calculate loop_counter movea.l A0,A2 ;set module base lsl.l #$2,D3 ;want 1/2 of in bytes lea (A2,D3.L),A3 ;set base of destination moveq #0,D3 ;clear sort_flag .CheckEntry cmpm.l (A2)+,(A3)+ ;compare entries bcc.b .SkipEntry ;branch if source lower move.l -4(A2),D4 ;swap entries move.l -4(A3),-4(A2) ;swap entries move.l D4,-4(A3) ;swap entries st D3 ;set flag (some sorted) st EFlag3(A5) ;set flag file changed .SkipEntry addq.l #1,D2 ;increment loop counter bmi.b .CheckEntry ;do until zero tst.b D3 ;sorted some bytes ? bne.b .Sort ;if so, sort part again! lsr.l #1,D1 ;increment sort_range bne.b .Sort ;sort next part until zero move.l A3,A0 ;get next module move.l (A0)+,D0 ;get # of relocs bne.b .SortModule ;sort next when set! .QuitSort bra Loop ;else, go back ***************************************************************************** MergeModules moveq #0,D0 ;set module # to search for moveq #0,D4 ;clear merge_flag movea.l A1,A2 ;set base of reloc_hunk addq.l #4,A2 ;skip hunk_id .SearchModule1 move.l A2,D3 ;prepare module_size move.l (A2)+,D1 ;get # of relocs .SearchModule2 move.l (A2)+,D2 ;get module # cmp.l D0,D2 ;we search for? beq.b .CopyModule ;branch if so .SkipModule lsl.l #2,D1 ;want size in bytes lea (A2,D1.l),A2 ;skip module move.l A2,D3 ;save base (current module) move.l (A2)+,D1 ;get # of relocs beq.b .MergeNextMod ;branch, no more modules move.l (A2)+,D2 ;get module # cmp.l D0,D2 ;we search for? bne.b .SkipModule ;branch if not .CopyModule tst.b D4 ;test merge_flag bne.b .JoinModule ;join module if set movea.l A3,A4 ;save buffer (# relocs) move.l D4,(A3)+ ;clear # of relocs move.l D2,(A3)+ ;set module # st D4 ;set flag (next must joined) .JoinModule add.l D1,(A4) ;increment # of relocs .CopyEntry move.l (A2)+,(A3)+ ;copy relocs subq.l #1,D1 ;decrement counter bne.b .CopyEntry ;do until zero sub.l A2,D3 ;calculate module length move.l A2,-(SP) ;save register .DeleteModule move.l (A2),(A2,D3.l) ;replace rest of reloc_hunk addq.l #4,A2 ;long by long cmpa.l A2,A3 ;do until bne.b .DeleteModule ;end of hunk movea.l (SP)+,A2 ;restore register adda.l D3,A2 ;reset address (next module) adda.l D3,A3 ;reset destination area adda.l D3,A4 ;reset ptr. (# of relocs) move.l A2,D3 ;save base (next module) move.l (A2)+,D1 ;get # of relocs bne.b .SearchModule2 ;branch if set .MergeNextMod addq.l #1,D0 ;inc. module # to search for moveq #0,D4 ;clear merge_flag movea.l A1,A2 ;get base of reloc_hunk addq.l #4,A2 ;skip hunk_id move.l (A2),(A3) ;all modules merged ? bne.b .SearchModule1 ;branch if not addq.l #4,A2 ;skip hunk_end .ResetNewHunk move.l (A2),-4(A2) ;reset merged reloc_hunk addq.l #4,A2 ;long by long cmp.l A3,A2 ;until bls.b .ResetNewHunk ;end of hunk rts ;go back ***************************************************************************** CopyDRel32 moveq #0,D0 ;prepare register moveq #0,D2 ;prepare register move.w (A2)+,D0 ;get # of relocs beq.b .SetEndMark ;branch if zero .CopyModule move.l D0,(A3)+ ;set # of relocs move.w (A2)+,D2 ;get module # move.l D2,(A3)+ ;write as long .CopyReloc move.w (A2)+,D2 ;get reloc move.l D2,(A3)+ ;write as long subq.l #1,D0 ;decrement reloc_counter bne.b .CopyReloc ;do until zero move.w (A2)+,D0 ;get # of relocs bne.b .CopyModule ;branch, copy module addq.l #1,D1 ;increment # of hunks copied st D7 ;flag, found drel32_hunk .SetEndMark move.l D0,(A3) ;set end_mark (zero) move.l A2,D0 ;be sure, we are long aligned addq.l #03,D0 ;calculate long_align andi.b #-4,D0 ;calculate long_align movea.l D0,A2 ;reset end_address rts ;go back ***************************************************************************** CopyReloc32 move.l (A2)+,D0 ;get # of relocs beq.b .SetEndMark ;branch if zero .CopyModule move.l D0,(A3)+ ;copy # of relocs move.l (A2)+,(A3)+ ;copy module number .CopyReloc move.l (A2)+,(A3)+ ;copy entry subq.l #1,D0 ;decrement counter bne.b .CopyReloc ;do for all entries move.l (A2)+,D0 ;get # of relocs bne.b .CopyModule ;branch, copy next module addq.l #1,D1 ;increment # of hunks copied .SetEndMark move.l D0,(A3) ;set end_mark (zero) rts ;go back *********************************************** save file to disk ********** SaveFile moveq #0,D4 ;initialize own error code bsr PresetBFName ;set backup filename move.l SPath(A5),D1 ;set pathpart beq.b MakeBackup ;use current dir. if unset moveq #ACCESS_READ,D2 ;set lock option jsr _LVOLock(A6) ;use DOS to (lock) dir. move.l D0,SPLock(A5) ;save lock beq.b SaveError ;branch on lock error move.l D0,D1 ;set lock jsr _LVOCurrentDir(A6) ;use DOS to set (currentdir) move.l D0,OldSDir(A5) ;save lock (prev. directory) MakeBackup lea BName(A5),A1 ;get filename (backup) move.l A1,D1 ;set filename jsr _LVODeleteFile(A6) ;use DOS to (deletefile) lea SName(A5),A0 ;get filename (save) lea BName(A5),A1 ;get filename (backup) move.l A0,D1 ;set oldname move.l A1,D2 ;set newname jsr _LVORename(A6) ;use DOS to (rename) file lea SName(A5),A1 ;get filename move.l A1,D1 ;set filename move.l #MODE_NEWFILE,D2 ;want open a new file jsr _LVOOpen(A6) ;use DOS to (open) file move.l D0,FHandleS(A5) ;save filehandle beq.b SaveError ;branch on failure move.l D0,D1 ;set filehandle move.l Memory(A5),D2 ;set buffer move.l NFSize(A5),D3 ;set length jsr _LVOWrite(A6) ;use DOS to (write) file move.l D0,D2 ;save success value move.l FHandleS(A5),D1 ;set filehandle jsr _LVOClose(A6) ;use DOS to (close) file tst.l D2 ;check for success bmi.b SaveError ;branch if not move.w #207,D4 ;preset (seek error) cmp.l D2,D3 ;all bytes written ? beq.b QuitSaveFile ;branch if so *********************************************** SaveError st EFlag4(A5) ;set flag (save error) bsr PrintError0 ;print some information addq.l #4,SP ;clear old return address pea Main3(pc) ;set new one lea SName(A5),A1 ;get filename move.l A1,D1 ;set filename jsr _LVODeleteFile(A6) ;delete corrupt file lea BName(A5),A0 ;get filename (backup) lea SName(A5),A1 ;get filename (save) move.l A0,D1 ;set oldname move.l A1,D2 ;set newname jsr _LVORename(A6) ;use DOS to (rename) file *********************************************** QuitSaveFile tst.b EFlag4(A5) ;save error ? bne.b ResetSDir ;branch if so tst.b Replace(A5) ;want to replace ? beq.b SetProtect ;branch if not tst.b EFlag1(A5) ;is it overlay ? bne.b SetProtect ;if so, force backup tst.b EFlag2(A5) ;removed some hunks/zeros ? bne.b SetProtect ;if so, force backup lea BName(A5),A1 ;get filename move.l A1,D1 ;set filename jsr _LVODeleteFile(A6) ;use DOS to (deletefile) SetProtect lea SName(A5),A3 ;get filename move.l A3,D1 ;set filename lea FIBlock(A5),A2 ;get fileinfoblock move.l fib_Protection(A2),D2 ;set protection bits bclr #FIBB_ARCHIVE,D2 ;clear archive bit jsr _LVOSetProtection(A6) ;use DOS to (setprotection) tst.b fib_Comment(A2) ;is there a comment ? beq.b ResetSDir ;branch if not move.l A3,D1 ;set filename lea fib_Comment(A2),A2 ;get comment move.l A2,D2 ;set comment jsr _LVOSetComment(A6) ;use DOS to (setcomment) ResetSDir move.l OldSDir(A5),D1 ;set former directory beq.b UnLockSDir ;branch if not set jsr _LVOCurrentDir(A6) ;use DOS to set (currentdir) UnLockSDir move.l SPLock(A5),D1 ;set dir. lock beq.b QuitSave ;branch if not set jsr _LVOUnLock(A6) ;use DOS to (unlock) dir. QuitSave rts ;go back *********************************************** preset backup name ********* PresetBFName moveq #-1,D0 ;prepare char counter lea SName(A5),A0 ;get savename buffer lea BName(A5),A1 ;get backup buffer lea Suffix(pc),A2 ;get suffix GetFNChar addq.l #1,D0 ;add char counter move.b (A0)+,(A1)+ ;copy char bne.b GetFNChar ;do it for all chars subq.l #1,A1 ;restore address AddSuffix sub.b #26,D0 ;is there room for suffix? bmi.b SetSuffix ;branch if so suba.l D0,A1 ;else, reduce stringsize SetSuffix move.b (A2)+,(A1)+ ;append extender bne.b SetSuffix ;until zero QuitSetName rts ;go back ***************************************************************************** Suffix dc.b ".bak",0,0 *********************************************** load file to memory ******** LoadFile moveq #0,D4 ;initialize own error code move.l LPLock(A5),D1 ;get dir. lock, preset by ASL bne.b GetDir ;branch if set move.l LPath(A5),D1 ;set pathpart beq.b GetFile ;use currentdir if unset moveq #ACCESS_READ,D2 ;set lock option jsr _LVOLock(A6) ;use DOS to (lock) dir. move.l D0,LPLock(A5) ;save lock beq LoadError ;branch on failure move.l D0,D1 ;set lock GetDir jsr _LVOCurrentDir(A6) ;use DOS to set (currentdir) move.l D0,OldLDir(A5) ;save lock (prev. directory) GetFile lea LName(A5),A1 ;get filename move.l A1,D1 ;set filename move.l #MODE_OLDFILE,D2 ;want open an existing file jsr _LVOOpen(A6) ;use DOS to (open) file move.l D0,FHandleL(A5) ;save filehandle beq.b LoadError ;branch on failure *********************************************** move.l D0,D1 ;set filehandle lea ProgID(A5),A2 ;get buffer (8 bytes) move.l A2,D2 ;set base moveq #8,D3 ;set size jsr _LVORead(A6) ;use DOS to (read) bytes tst.l D0 ;test for success bmi.b LoadError ;branch if not *********************************************** move.w #305,D4 ;preset io_error (not exec.) cmp.l D0,D3 ;8 bytes loaded ? bne.b LoadError ;branch if not?!?! hmmm... cmp.l #HUNK_HEADER,(A2) ;check for executable bne.b LoadError ;branch if not tst.l 4(A2) ;check for executable bne.b LoadError ;branch if not *********************************************** move.l FHandleL(A5),D1 ;set filehandle lea FIBlock(A5),A3 ;get fileinfoblock move.l A3,D2 ;set fib jsr _LVOExamineFH(A6) ;use DOS to (examinefh) tst.l D0 ;test for success beq.b LoadError ;branch if not move.l fib_Size(A3),D0 ;set filesize add.l D0,D0 ;add working area moveq #0,D1 ;no memory options movea.l 4.w,A6 ;set EXEC to call a function jsr _LVOAllocMem(A6) ;use EXEC to (allocmem) movea.l DOSBase(A5),A6 ;set DOS to call a function move.l D0,Memory(A5) ;save memorybase beq.b LoadError ;branch when no free store *********************************************** movea.l D0,A0 ;set membase move.l (A2)+,(A0)+ ;copy hunk_id move.l (A2)+,(A0)+ ;copy hunk_id move.l FHandleL(A5),D1 ;set filehandle move.l A0,D2 ;set membase move.l fib_Size(A3),D3 ;set filesize subq.l #8,D3 ;skip hunk_id beq.b LoadError ;no more bytes?!?! hmmm... jsr _LVORead(A6) ;use DOS to (read) bytes tst.l D0 ;test for success bmi.b LoadError ;branch if not move.w #219,D4 ;preset io_error (seek error) cmp.l D0,D3 ;got we all bytes ? beq.b CloseLFile ;branch if so *********************************************** LoadError bsr.b PrintError0 ;print error information addq.l #4,SP ;clear old return address pea Main3(pc) ;set new return address *********************************************** CloseLFile move.l FHandleL(A5),D1 ;set filehandle beq.b ResetDir ;branch if not set jsr _LVOClose(A6) ;use DOS to (close) file ResetDir move.l OldLDir(A5),D1 ;set former directory beq.b UnLockLDir ;branch if not set jsr _LVOCurrentDir(A6) ;use DOS to set (currentdir) UnLockLDir tst.b ASLFlag(A5) ;got file by ASL ? bne.b QuitLoad ;branch if so move.l LPLock(A5),D1 ;set dir. lock beq.b QuitLoad ;branch if not set jsr _LVOUnLock(A6) ;use DOS to (unlock) dir. QuitLoad rts ;go back *********************************************** print hunk error *********** PrintError2 addq #4,SP ;clear old return address pea Main3(pc) ;set new one moveq #0,D5 ;prepare register moveq #0,D4 ;prepare register move.w #212,D4 ;set error code (wrong type) bra.b PrintFailed0 ;print error information *********************************************** print hunk error *********** PrintError1 addq #4,SP ;clear old return address pea Main3(pc) ;set new one moveq #0,D5 ;prepare register moveq #0,D4 ;prepare register move.w #235,D4 ;set error code (bad hunk) bra.b PrintFailed0 ;print error information *********************************************** get load/save error ******** PrintError0 jsr _LVOIoErr(A6) ;use DOS to get (io_error) move.l D0,D5 ;save io_error *********************************************** print error information **** PrintFailed0 move.b Quiet(A5),D0 ;test quiet-flag beq.b PrintFailed1 ;branch if unset bsr.b PrintET01 ;print filename first move.b EFlag1(A5),D0 ;test for overlay found beq.b PrintFailed2 ;branch if unset bsr.b PrintET05 ;print text "contains ovl." PrintFailed2 move.b EFlag4(A5),D0 ;test for saving file beq.b PrintFailed1 ;branch if unset bsr.b PrintET02 ;print text "writing" PrintFailed1 bsr.b PrintET03 ;print text "*** FAILED ***" move.l D5,D1 ;set io_error bgt.b PrintFault2 ;branch if one move.l D4,D1 ;force own error PrintFault2 move.l D1,IOErr(A5) ;save io_error lea Header2(pc),A0 ;get header text move.l A0,D2 ;set header text jsr _LVOPrintFault(A6) ;use DOS to (printfault) moveq #1,D0 ;set failat level add.l D0,RCode(A5) ;set returncode rts ;go back / go main3 *********************************************** print some information ***** PrintET05 lea Text05(pc),A0 ;get text "contains overlay" bra.b PrintText0 ;and print PrintET03 lea Text03(pc),A0 ;get text "*** FAILED ***" bra.b PrintText0 ;and print PrintET02 lea Text02(pc),A0 ;get text "writing" bra.b PrintText0 ;and print PrintET01 lea Text01(pc),A0 ;get text "FILE:" bsr.b PrintText0 ;and print lea LName(A5),A0 ;get filename bra.b PrintText0 ;and print *********************************************** PrintT06 lea Text06(pc),A0 ;get text "untouched" bra.b PrintText1 ;and print PrintT05 lea Text05(pc),A0 ;get text "contains overlay" bra.b PrintText1 ;and print PrintT04 lea Text04(pc),A0 ;get text "done." bra.b PrintText1 ;and print PrintT02 lea Text02(pc),A0 ;get text "writing" bra.b PrintText1 ;and print PrintT00 lea Text00(pc),A0 ;get text "processing" bsr.b PrintText1 ;and print lea Text01(pc),A0 ;get text "FILE:" bsr.b PrintText1 ;and print lea LName(A5),A0 ;get filename *********************************************** printtext (null-terminated) * PrintText1 move.b Quiet(A5),D0 ;test quiet-flag bne.b QuitPrint ;branch if set *********************************************** PrintText0 move.l A0,D2 ;set text to print moveq #-1,D3 ;prepare register CalcSize addq.l #1,D3 ;calculate tst.b (A0)+ ;text length bne.b CalcSize ;until null-byte jsr _LVOOutput(A6) ;use DOS to find (output) move.l D0,D1 ;set output-handle jsr _LVOWrite(A6) ;use DOS to (write) text QuitPrint rts ;go back *********************************************** printtext (null-terminated) * PrintTBS move.b Quiet(A5),D0 ;test quiet-flag bne.b QuitPrintSB ;branch if set lea Text07(pc),A1 ;get text "%ld bytes " lea RdSize(A5),A2 ;get buffer lea Text09(pc),A3 ;get text "lost" tst.l (A2) ;saved some ? beq.b QuitPrintSB ;branch if not bpl.b PrintSBytes ;lost some ? neg.l (A2) ;need positive lea Text08(pc),A3 ;get text "saved" PrintSBytes move.l A1,D1 ;set text move.l A2,D2 ;set argv jsr _LVOVPrintf(A6) ;use DOS to (vprintf) move.l A3,D1 ;set text jsr _LVOPutStr(A6) ;use DOS to (putstr) jsr _LVOOutput(A6) ;use DOS to find (output) move.l D0,D1 ;set output-handle jsr _LVOFlush(A6) ;use DOS to (flush) handle QuitPrintSB rts ;go back ***************************************************************************** Text00 dc.b "processing",0 Text01 dc.b " FILE: ",0 Text02 dc.b ", writing...",0 Text03 dc.b " *** FAILED ***",$A,0 Text04 dc.b " done.",$A,0 Text05 dc.b ", contains overlay",0 Text06 dc.b ", untouched.",$A,0 Text07 dc.b ", %ld bytes ",0 Text08 dc.b "saved",0 Text09 dc.b "lost",0 Header2 dc.b "ERROR",0 even *********************************************** prepare file/dir (dst.) **** PrepSDst move.l LPath(A5),SPath(A5) ;copy pathpart_ptr lea LName(A5),A0 ;get buffer fname (load) lea SName(A5),A1 ;set buffer fname (save) SetSName move.b (A0)+,(A1)+ ;preset filename bne.b SetSName ;until zero move.l SREQBase(A5),D1 ;set save_requester base bne.b PrepSASL ;branch if set move.l SFile(A5),D2 ;check for dst. filename beq.b QuitPrepSArg ;branch if not set move.l D1,SPath(A5) ;clear pathpart_ptr move.l D2,D1 ;set filename jsr _LVOFilePart(A6) ;use DOS to find (filepart) movea.l D0,A0 ;set base of filename lea SName(A5),A1 ;set buffer (max: 30 chars) bsr.b CopyFName ;copy filename cmp.l D0,D2 ;is there a pathpart ? beq.b QuitPrepSArg ;branch if not move.l D2,SPath(A5) ;save pathpart_ptr QuitPrepSArg rts ;go back *********************************************** PrepSASL movea.l D1,A2 ;set sreqbase movea.l fr_Drawer(A2),A0 ;get pathpart tst.b (A0) ;is there one ? beq.b GetSFASL ;no, branch move.l A0,SPath(A5) ;set pathpart GetSFASL movea.l fr_File(A2),A0 ;get filename tst.b (A0) ;is there one ? beq.b QuitSFASL ;no,branch lea SName(A5),A1 ;set buffer bsr.b CopyFName ;copy filename QuitSFASL rts ;go back *********************************************** prepare file/dir (src.) **** PrepLSrc move.l FileCnt(A5),D0 ;get file counter move.l ASLFlag(A5),D1 ;check for ASL bne.b PrepLASL ;branch if so ************************************************ PrepLARG lsl.l #2,D0 ;use D0 as offset movea.l LFile(A5),A2 ;set source list move.l 0(A2,D0.w),D2 ;get base of next filename move.l D2,D1 ;set filename jsr _LVOFilePart(A6) ;use DOS to find (filepart) movea.l D0,A0 ;set base of filename lea LName(A5),A1 ;set buffer (max: 30 chars) bsr.b CopyFName ;copy filename cmp.l D0,D2 ;is there a pathpart ? beq.b QuitPrepLArg ;branch if not move.l D2,LPath(A5) ;save pointer QuitPrepLArg rts ;go back *********************************************** prepare asl filename ******* PrepLASL lsl.l #3,D0 ;use D0 as offset movea.l LREQBase(A5),A2 ;get requester base movea.l fr_ArgList(A2),A2 ;set filetable move.l 0(A2,D0.w),LPLock(A5) ;copy lock movea.l 4(A2,D0.w),A0 ;set filename lea LName(A5),A1 ;set buffer (max: 30 chars) *********************************************** CopyFName move.b (A0),(A1)+ ;copy first byte move.b #0,(A0)+ ;set pathpart terminator CopyChar move.b (A0)+,(A1)+ ;copy bytes (max: 30 chars) bne.b CopyChar ;until zero rts ;go back *********************************************** check for break signal ***** ChkBreak moveq #00,D1 ;prepare signal mask bset #12,D1 ;set break bit (ctrl_c) jsr _LVOCheckSignal(A6) ;use DOS to (checksignal) btst #12,D0 ;test break bit (ctrl_c) bne ForceFault3 ;if set, branch (set ioerr) rts ;go back *********************************************** open asl requester (load) ** OpenREQs tst.l AslReq(A5) ;test flag beq ForceFault1 ;if unset, branch (arg miss.) move.l ASLBase(A5),D6 ;is there ASL available ? beq ForceFault4 ;print (invalid lib.) if not moveq #0,D0 ;want a filerequester lea ASLTAG_L(pc),A0 ;set taglist moveq #1,D1 ;set tag item boolean value lea Title_L2(pc),A1 ;get tag item req_title move.l D1,12(A0) ;set multiselect (true) move.l A1,04(A0) ;set req_title movea.l D6,A6 ;set ASL to call a function jsr _LVOAllocAslRequest(A6) ;use ASL to (allocaslrequest) move.l D0,LREQBase(A5) ;save req_base beq PrintFault0 ;branch on failure movea.l D0,A0 ;set req_base suba.l A1,A1 ;no more tags yet jsr _LVOAslRequest(A6) ;use ASL to open (aslrequest) tst.l D0 ;test result beq PrintFault0 ;branch on failure movea.l LREQBase(A5),A2 ;set requester base move.l fr_NumArgs(A2),D2 ;read number of files subq.l #1,D2 ;prepare filecounter move.l D2,FileCnt(A5) ;and save *********************************************** open asl requester (save) ** moveq #0,D0 ;want a filerequester lea ASLTAG_S(pc),A0 ;set taglist moveq #1,D1 ;set tag item (drawers only) lea Title_S2(pc),A1 ;get tag item req_title2 suba.l A3,A3 ;clear initialfile tst.l D2 ;test for multiple files bne.b OpenLFile ;branch if so moveq #0,D1 ;unset tag item (drawers.. ) lea Title_S1(pc),A1 ;get tag item req_title1 movea.l fr_File(A2),A3 ;get initialfile OpenLFile move.l D1,D3 ;save boolean (temp.) move.l A3,20(A0) ;set initialfile move.l D1,12(A0) ;set boolean value move.l A1,04(A0) ;set req_title jsr _LVOAllocAslRequest(A6) ;use ASL to (allocaslrequest) move.l D0,SREQBase(A5) ;save req_base beq PrintFault0 ;branch on failure movea.l D0,A0 ;set req_base suba.l A1,A1 ;no more tags yet jsr _LVOAslRequest(A6) ;use ASL to open (aslrequest) tst.l D0 ;test result beq PrintFault0 ;branch on failure movea.l SREQBase(A5),A2 ;set requester base movea.l fr_File(A2),A2 ;get filename tst.b (A2) ;test for empty bne.b QuitREQ ;branch if not tst.l D3 ;test boolean (drawers only) beq ForceFault1 ;if unset, branch (arg mis.) QuitREQ st ASLFlag(A5) ;set flag (using ASL) rts ;go back ***************************************************************************** ASLTAG_L dc.l ASLFR_TitleText,0 dc.l ASLFR_DoMultiSelect,0 dc.l ASLFR_DoPatterns,1,0 ASLTAG_S dc.l ASLFR_TitleText,0 dc.l ASLFR_DrawersOnly,0 dc.l ASLFR_InitialFile,0 dc.l ASLFR_DoSaveMode,1,0 Title_L2 dc.b "Select your files...",0 Title_S1 dc.b "Save file as...",0 Title_S2 dc.b "Select drawer to save...",0 even *********************************************** check for wrong arguments ** CheckArgs move.b DRel32(A5),D0 ;get flag, want drel32? and.b Reloc32(A5),D0 ;get flag, want reloc32? bne ForceFault2 ;error, one flag only! move.b DRel32(A5),D0 ;get flag, want drel32? bne.b CheckFlags ;branch if so move.b Split(A5),D0 ;get flag, want split? bne ForceFault2 ;error, requires drel32! CheckFlags or.b Reloc32(A5),D0 ;one of these must be set or.b Sort(A5),D0 ;one of these must be set or.b Symbol(A5),D0 ;one of these must be set or.b Debug(A5),D0 ;one of these must be set or.b Name(A5),D0 ;one of these must be set or.b Zeros(A5),D0 ;one of these must be set beq ForceFault1 ;error if not ************************************************ sort reverse (7.11.00) ***** move.b Reverse(A5),D0 ;get flag (sort reverse) beq.b .Ready ;branch if not set and.b Sort(A5),D0 ;reverse requires sort beq ForceFault1 ;branch if not set lea SortDRel32(pc),A0 ;patch sortroutine (drel32) subq.b #1,30(A0) ;from bhi -> bls lea SortReloc32(pc),A0 ;patch sortroutine (reloc32) subq.b #1,30(A0) ;from bhi -> bls movea.l 4.w,A6 ;set EXEC to call a function jsr _LVOCacheClearU(A6) ;use EXEC to clear cache ***************************************************************************** .Ready tst.l LFile(A5) ;test source list bne.b CountFiles ;branch if set tst.l SFile(A5) ;test destination bne ForceFault1 ;branch if set (arg missing) rts ;go back *********************************************** CountFiles tst.l AslReq(A5) ;test flag bne ForceFault2 ;branch if set (wrong number) movea.l LFile(A5),A1 ;get filetable tst.l (A1)+ ;skip first one moveq #0,D0 ;initialize file counter tst.l (A1)+ ;check for another entry beq.b QuitChkArgs ;branch if empty tst.l SFile(A5) ;is there a destination ? bne ForceFault2 ;branch if so (wrong number) CntFiles addq #1,D0 ;increment file counter tst.l (A1)+ ;check next list-entry bne.b CntFiles ;until all files found QuitChkArgs addq #4,SP ;skip openreqs-routine pea Main1(pc) ;set new return address move.l D0,FileCnt(A5) ;save file count rts ;go main1 *********************************************** read arguments ************* ReadArgs lea Template(pc),A0 ;get argument template lea ArgArray(A5),A1 ;get buffer (readarg array) move.l A0,D1 ;set template move.l A1,D2 ;set array moveq #0,D3 ;no readarg structure movea.l DOSBase(A5),A6 ;set DOS to call a function jsr _LVOReadArgs(A6) ;use DOS to (readarg) move.l D0,RArgPtr(A5) ;save pointer beq PrintFault0 ;branch on fail rts ;go back ************************************************ sort reverse (7.11.00) ***** Template dc.b "FILE/M,TO=AS,REPLACE/S,DREL32/S,SPLIT/S,RELOC32/S,SORT/S," dc.b "REVERSE/S,SYMBOL/S,DEBUG/S,NAME/S,ZEROS/S,ASLREQ/S,QUIET/S",0 even *********************************************** prepare pr_result2 error *** ForceFault4 move.w #122,D1 ;preset ioerr (invalid lib.) bra.b ForceFault0 ;branch (set ioerr) ForceFault3 move.w #304,D1 ;preset ioerr (break by user) bra.b ForceFault0 ;branch (set ioerr) ForceFault2 move.w #118,D1 ;preset ioerr (to many args) bra.b ForceFault0 ;branch (set ioerr) ForceFault1 move.w #116,D1 ;preset ioerr (args missing) ForceFault0 ext.l D1 ;clear upper word movea.l DOSBase(A5),A6 ;set DOS to call a function jsr _LVOSetIoErr(A6) ;use DOS to (setioerr) *********************************************** print pr_result2 error ***** PrintFault0 movea.l DOSBase(A5),A6 ;set DOS to call a function jsr _LVOIoErr(A6) ;use DOS to get (ioerr) move.l D0,D1 ;set io_error beq.b ForceFault1 ;branch when got nothing moveq #0,D2 ;prepare register (no header) cmp.w #304,D1 ;check for break by user beq.b PrintFault1 ;branch if so lea Header1(pc),A2 ;get header text move.l A2,D2 ;want to print PrintFault1 jsr _LVOPrintFault(A6) ;use DOS to (printfault) addq.l #4,SP ;clear old return address pea Main4(pc) ;set new return address moveq #5,D0 ;set failat level (WARN) move.l D0,RCode(A5) ;set returncode rts ;quit program ***************************************************************************** Header1 dc.b "StripHunk",0 ***************************************************************************** if BSS_Section SECTION StripHunk_bss,BSS elseif cnop 0,4 endc ***************************************************************************** DataBase ds.b BSS_Size1 end of file ****************************************************************